package com.jysz.certificate.utils;

import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.LinkedList;
import java.util.Locale;
import java.util.TimeZone;

import org.apache.commons.lang3.time.DateFormatUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.springframework.util.Assert;



/**
 * 日期工具类 
 * @author kacarich email:javaengine@outlook.com
 *
 */
public class DateUtil {
	public static final String DEFAULT_DATE_PATTERN = "yyyy/MM/dd";

	public static final String DATE_DATABASE_PATTERN = "yyyy-MM-dd HH:mm:ss";
	public static final String DATE_FORMAT = "yyyy-MM-dd";
	
	/**
	 * 根据年月日获得指定的日期
	 * 
	 * @param year
	 *            年份
	 * @param month
	 *            月份
	 * @param day
	 *            日期
	 * @return 相应的 Date 型日期
	 */
	public static Date getDate(int year, int month, int day) {
		Assert.isTrue(month > 0 && month < 13);
		Calendar calendar = Calendar.getInstance();
		calendar
				.set(year, convertRealMonthToCalendarMonth(month), day, 0, 0, 0);
		return calendar.getTime();
	}

	/**
	 * 通过字符串，规定日期 0小时，0分，0秒
	 * 
	 * @param date
	 * @return
	 */
	public static Date getDate(String strDate) {
		return getDate(strDate, "yyyy-MM-dd");
	}

	/**
	 * 通过字符串，获得时间
	 * 
	 * @param date
	 * @return
	 */
	public static Date getDate(String strDate, String format) {
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format,
				java.util.Locale.CHINA);
		Date date = null;

		try {
			date = simpleDateFormat.parse(strDate);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}
	
	/**
	 * 根据给定的年月日小时分钟秒创建一个日期
	 * 
	 * @param year
	 *            年份
	 * @param month
	 *            月份
	 * @param day
	 *            日期
	 * @param hour
	 *            小时
	 * @param minute
	 *            分钟
	 * @param second
	 *            秒
	 * @return 返回一个对应的日期
	 */
	public static Date getDateTime(int year, int month, int day, int hour,
			int minute, int second) {
		Assert.isTrue(month > 0 && month <= 12);
		Assert.isTrue(hour >= 0 && hour <= 23);
		Assert.isTrue(minute >= 0 && minute <= 60);
		Assert.isTrue(second >= 0 && second <= 60);
		Calendar calendar = Calendar.getInstance();
		calendar.set(year, convertRealMonthToCalendarMonth(month), day, hour,
				minute, second);
		return calendar.getTime();
	}

	/**
	 * 判断两个日期是否相等
	 * 
	 * @param date1
	 *            日期1
	 * @param date2
	 *            日期2
	 * @return 相等时返回 true
	 */
	public static boolean isSameDay(Date date1, Date date2) {
		Assert.notNull(date1);
		Assert.notNull(date2);
		return DateUtils.isSameDay(date1, date2);
	}


	/**
	 * 判断给定日期是否为当月的最后一天
	 * 
	 * @param date
	 *            指定的日期
	 * @return 当该日期为当月最后一天则返回 true
	 */
	public static boolean isEndOfTheMonth(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		int maxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
		return calendar.get(Calendar.DATE) == maxDay;
	}

	/**
	 * 判断给定日期是否为当年的最后一天
	 * 
	 * @param date
	 *            指定的日期
	 * @return 当该日期为当年最后一天则返回 true
	 */
	public static boolean isEndOfTheYear(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return (11 == calendar.get(Calendar.MONTH))
				&& (31 == calendar.get(Calendar.DATE));
	}
	 /**
     * 某一个月第一天 
     * @param date
     * @return
     */
	public static Date getFirstdayLastdayMonthOne(Date date) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
//        calendar.add(Calendar.MONTH, -1);
        Date theDate = calendar.getTime();
        
        //上个月第一天
        GregorianCalendar gcLast = (GregorianCalendar) Calendar.getInstance();
        gcLast.setTime(theDate);
        gcLast.set(Calendar.DAY_OF_MONTH, 1);
        String day_first = df.format(gcLast.getTime());
        StringBuffer str = new StringBuffer().append(day_first).append(" 00:00:00");
        day_first = str.toString();
        Date dayeDate=null;
        
        try {
        	dayeDate = df.parse(day_first);
		} catch (ParseException e) {
			e.printStackTrace();
		}
        return dayeDate;
    }
	/**
     * 某一个季度第一天 
     * @param date
     * @return
     */
	public static Date getFirstdayLastdayMonthQuarterOne(Date date,int MM) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MONTH, MM);
        Date theDate = calendar.getTime();
        
        //上个月第一天
        GregorianCalendar gcLast = (GregorianCalendar) Calendar.getInstance();
        gcLast.setTime(theDate);
        gcLast.set(Calendar.DAY_OF_MONTH, 1);
        String day_first = df.format(gcLast.getTime());
        StringBuffer str = new StringBuffer().append(day_first).append(" 00:00:00");
        day_first = str.toString();
        Date dayeDate=null;
        
        try {
        	dayeDate = df.parse(day_first);
		} catch (ParseException e) {
			e.printStackTrace();
		}
        return dayeDate;
    }
	/**
     * 某一个季度最后一天
     * @param date
     * @return
     */
	public static Date getFirstdayLastdayMonthQuarter(Date date) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        
        
        //上个月最后一天
        calendar.add(Calendar.MONTH, 1);    //加一个月
        calendar.set(Calendar.DATE, 1);        //设置为该月第一天
        calendar.add(Calendar.DATE, -1);    //再减一天即为上个月最后一天
        String day_last = df.format(calendar.getTime());
        StringBuffer endStr = new StringBuffer().append(day_last).append(" 23:59:59");
        day_last = endStr.toString();

        Date dayeDate=null;
        
        try {
        	dayeDate = df.parse(day_last);
		} catch (ParseException e) {
			e.printStackTrace();
		}
        return dayeDate;
    }
    /**
     * 某一个月 最后一天
     * @param date
     * @return
     */
	public static Date getFirstdayLastdayMonth(Date date) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
//        calendar.add(Calendar.MONTH, -1);
        
        //上个月最后一天
        calendar.add(Calendar.MONTH, 1);    //加一个月
        calendar.set(Calendar.DATE, 1);        //设置为该月第一天
        calendar.add(Calendar.DATE, -1);    //再减一天即为上个月最后一天
        String day_last = df.format(calendar.getTime());
        StringBuffer endStr = new StringBuffer().append(day_last).append(" 23:59:59");
        day_last = endStr.toString();

        Date dayeDate=null;
        
        try {
        	dayeDate = df.parse(day_last);
		} catch (ParseException e) {
			e.printStackTrace();
		}
        return DateUtil.getEndDate(dayeDate);
    }

	/**
	 * 获得给定日期的月份的最后一天
	 * 
	 * @param date
	 *            指定的日期
	 * @return 指定日期月份的最后一天
	 */
	public static int getLastDayOfTheMonth(Date date) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 判断开始日期是否比结束日期早
	 * 
	 * @param startDate
	 *            开始日期
	 * @param endDate
	 *            结束日期
	 * @return 当开始日期比结束日期早时返回 true
	 */
	public static boolean isStartBeforeEndDate(Date startDate, Date endDate) {
		Assert.notNull(startDate, "StartDate is null");
		Assert.notNull(endDate, "EndDate is null");
		return resetTime(startDate).compareTo(resetTime(endDate)) < 0;
	}

	/**
	 * 判断开始日期是否比结束日期早
	 * 
	 * @param startTime
	 *            开始时间
	 * @param endTime
	 *            结束时间
	 * @return 当开始时间比结束时间早时返回 true
	 */
	public static boolean isStartBeforeEndTime(Date startTime, Date endTime) {
		Assert.notNull(startTime, "StartTime is null");
		Assert.notNull(endTime, "EndTime is null");
		return startTime.getTime() <= endTime.getTime();
	}
	/**
	 * 判断开始日期是否比结束日期晚
	 * 
	 * @param startTime
	 *            开始时间
	 * @param endTime
	 *            结束时间
	 * @return 当开始时间比结束时间早时返回 true
	 */
	public static boolean isNotBeforeEndTime(Date startTime, Date endTime) {
		Assert.notNull(startTime, "StartTime is null");
		Assert.notNull(endTime, "EndTime is null");
		return startTime.getTime() >= endTime.getTime();
	}

	/**
	 * 判断给定日期是否为对应日期月份的第一天
	 * 
	 * @param date
	 *            给定日期
	 * @return 当给定日期是否为对应日期月份的第一天返回 true
	 */
	public static boolean isStartOfTheMonth(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return 1 == calendar.get(Calendar.DATE);
	}

	/**
	 * 判断给定日期是否为对应日期年份的第一天
	 * 
	 * @param date
	 *            给定日期
	 * @return 当给定日期是否为对应日期年份的第一天返回 true
	 */
	public static boolean isStartOfTheYear(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return (0 == calendar.get(Calendar.MONTH))
				&& (1 == calendar.get(Calendar.DATE));
	}

	/**
	 * 获取给定日期的月份
	 * 
	 * @param date
	 *            给定日期
	 * @return 给定日期的月份
	 */
	public static int getMonth(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return convertCalendarMonthToRealMonth(calendar.get(Calendar.MONTH));
	}

	/**
	 * 获取给定日期的年份
	 * 
	 * @param date
	 *            给定日期
	 * @return 给定日期的年份
	 */
	public static int getYear(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.YEAR);
	}

	/**
	 * 获取给定日期的是该周的第几天
	 * 
	 * @param date
	 *            给定日期
	 * @return 给定日期的是该周的第几天
	 */
	public static int getDayOfWeek(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.DAY_OF_WEEK) - 1;
	}

	public static String getStringDayofWeek(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		String dayName = "";
		switch (calendar.get(Calendar.DAY_OF_WEEK)) {
		case Calendar.SUNDAY:
			dayName = "星期日";
			break;
		case Calendar.MONDAY:
			dayName = "星期一";
			break;
		case Calendar.TUESDAY:
			dayName = "星期二";
			break;
		case Calendar.WEDNESDAY:
			dayName = "星期三";
			break;
		case Calendar.THURSDAY:
			dayName = "星期四";
			break;
		case Calendar.FRIDAY:
			dayName = "星期五";
			break;
		case Calendar.SATURDAY:
			dayName = "星期六";
			break;
		}
		return dayName;
	}

	/**
	 * 获取给定日期是该月的第几天
	 * 
	 * @param date
	 *            给定日期
	 * @return 给定日期是该月的第几天
	 */
	public static int getDayOfMonth(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.DAY_OF_MONTH);
	}

	/**
	 * 获取给定日期是当年的第几天
	 * 
	 * @param date
	 *            给定日期
	 * @return 给定日期是当年的第几天
	 */
	public static int getDayOfYear(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.DAY_OF_YEAR);
	}

	/**
	 * 获取给定日期是当天的几点
	 * 
	 * @param date
	 *            给定日期
	 * @return 给定日期是当天的几点
	 */
	public static int getHour(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.HOUR_OF_DAY);
	}

	/**
	 * 获取给定日期的分钟
	 * 
	 * @param date
	 *            给定日期
	 * @return 给定日期的分钟
	 */
	public static int getMinute(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.MINUTE);
	}

	/**
	 * 获取给定日期的秒数
	 * 
	 * @param date
	 *            给定日期
	 * @return 给定日期的秒数
	 */
	public static int getSecond(Date date) {
		Assert.notNull(date);
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(Calendar.SECOND);
	}

	/**
	 * 获取不含不含小时分钟秒的系统日期
	 * 
	 * @return 系统当前日期，不含小时分钟秒
	 */
	public static Date getSystemDate() {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.HOUR_OF_DAY, 0);
		calendar.set(Calendar.MINUTE, 0);
		calendar.set(Calendar.SECOND, 0);
		calendar.set(Calendar.MILLISECOND, 0);
		return new Date(calendar.getTime().getTime());
	}

	/**
	 * 获取系统的 Timestamp
	 * 
	 * @return 系统当前时间的 Timestamp
	 */
	public static Timestamp getSystemTimestamp() {
		return new Timestamp(System.currentTimeMillis());
	}

	/**
	 * 给指定日期加几秒
	 * 
	 * @param date
	 *            指定的日期
	 * @param numSeconds
	 *            需要往后加的秒数
	 * @return 加好后的日期
	 */
	public static Date addSeconds(Date date, int numSeconds) {
		Assert.notNull(date);
		return DateUtils.addSeconds(date, numSeconds);
	}

	/**
	 * 给指定日期加几天
	 * 
	 * @param date
	 *            指定的日期
	 * @param numDays
	 *            需要往后加的天数
	 * @return 加好后的日期
	 */
	public static Date addDays(Date date, int numDays) {
		Assert.notNull(date);
		return DateUtils.addDays(date, numDays);
	}
	/**
	 * 给指定日期减几天
	 * 
	 * @param date 指定的日期
	 * @param numDays 需要减的天数
	 * @return 减好后的日期
	 */
	public static Date addCutDays(Date beginDate, int numDays) {
		SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM-dd");
		Calendar date = Calendar.getInstance();
		date.setTime(beginDate);
		date.set(Calendar.DATE, date.get(Calendar.DATE) - numDays);
		Date endDate=null;
		try {
			endDate = dft.parse(dft.format(date.getTime()));
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return endDate;
	}

	/**
	 * 给指定日期加几个小时
	 * 
	 * @param date
	 *            指定的日期
	 * @param numHours
	 *            需要往后加的小时数
	 * @return 加好后的日期
	 */
	public static Date addHours(Date date, int numHours) {
		Assert.notNull(date);
		return DateUtils.addHours(date, numHours);
	}

	/**
	 * 给指定日期加几分钟
	 * 
	 * @param date
	 *            指定的日期
	 * @param numMins
	 *            需要往后加的分钟数
	 * @return 加好后的日期
	 */
	public static Date addMinutes(Date date, int numMins) {
		Assert.notNull(date);
		return DateUtils.addMinutes(date, numMins);
	}

	/**
	 * 给指定日期加几个月
	 * 
	 * @param date
	 *            指定的日期
	 * @param numMonths
	 *            需要往后加的月数
	 * @return 加好后的日期
	 */
	public static Date addMonths(Date date, int numMonths) {
		Assert.notNull(date);
		return DateUtils.addMonths(date, numMonths);
	}

	/**
	 * 给指定日期加几年
	 * 
	 * @param date
	 *            指定的日期
	 * @param numYears
	 *            需要往后加的年数
	 * @return 加好后的日期
	 */
	public static Date addYears(Date date, int numYears) {
		Assert.notNull(date);
		return DateUtils.addYears(date, numYears);
	}

	/**
	 * 将日期转换为默认的格式
	 * 
	 * @param date
	 *            指定的日期
	 * @return 格式化好后的日期字符串
	 */
	public static String formatDate(Date date) {
		if (date != null) {
			return DateFormatUtils.format(date, DEFAULT_DATE_PATTERN);
		} else {
			return "";
		}
	}

	/**
	 * 将一个指定的日期格式化成指定的格式
	 * 
	 * @param date
	 *            指定的日期
	 * @param pattern
	 *            指定的格式
	 * @return 格式化好后的日期字符串
	 */
	public static String formatDate(Date date, String pattern) {
		if (date != null) {
			return DateFormatUtils.format(date, pattern);
		} else {
			return "";
		}
	}

	/**
	 * 将一个指定的日期格式化成指定时区，指定 Locale 的指定的格式
	 * 
	 * @param date
	 *            指定的日期
	 * @param pattern
	 *            指定的格式
	 * @param timezone
	 *            指定的时区
	 * @param locale
	 *            指定的 Locale
	 * @return 格式化好后的日期字符串
	 */
	public static String formatDate(Date date, String pattern,
			TimeZone timezone, Locale locale) {
		return DateFormatUtils.format(date, pattern, timezone, locale);
	}

	/**
	 * 将指定日期的小时、分钟、秒清零
	 * 
	 * @param date
	 *            指定的日期
	 * @return 小时、分钟、秒被清零的日期
	 */
	public static Date resetTime(Date date) {
		Assert.notNull(date);
		return getDate(getYear(date), getMonth(date), getDayOfMonth(date));
	}

	/**
	 * 将一个字符串转换成默认格式的日期
	 * 
	 * @param strDateTime
	 *            需要转换的日期字符串
	 * @return 当转换成功返回转换成功后的日期，否则返回 null
	 */
	public static Date parseDate(String strDateTime) {
		try {
			return DateUtils.parseDate(strDateTime,
					new String[] { DEFAULT_DATE_PATTERN });
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 将一个字符串转换成指定格式的日期
	 * 
	 * @param strDateTime
	 *            需要转换的日期字符串
	 * @param pattern
	 *            转换的格式
	 * @return 当转换成功返回转换成功后的日期，否则返回 null
	 */
	public static Date parseDate(String strDateTime, String pattern) {
		try {
			return DateUtils.parseDate(strDateTime, new String[] { pattern });
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 将一个字符串转换成指定格式的日期
	 * 
	 * @param strDateTime
	 *            需要转换的日期字符串
	 * @param patterns
	 *            转换的格式数组，包含多个转换格式，其中任何一种匹配都可以转换成功
	 * @return 当转换成功返回转换成功后的日期，否则返回 null
	 */
	public static Date parseDate(String strDateTime, String[] patterns) {
		try {
			return DateUtils.parseDate(strDateTime, patterns);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 将一个字符串转换成指定格式的Timestamp
	 * 
	 * @param strDateTime
	 *            需要转换的时间字符串
	 * @param pattern
	 *            转换的格式
	 * @return 当转换成功返回转换成功后的 Timestamp，否则返回 null
	 */
	public static Timestamp parseTimestamp(String strDateTime, String pattern) {
		return toTimestamp(parseDate(strDateTime, pattern));
	}

	/**
	 * 将一个字符串转换成指定格式的Timestamp
	 * 
	 * @param strDateTime
	 *            需要转换的时间字符串
	 * @param patterns
	 *            转换的格式数组，包含多个转换格式，其中任何一种匹配都可以转换成功
	 * @return 当转换成功返回转换成功后的 Timestamp，否则返回 null
	 */
	public static Timestamp parseTimestamp(String strDateTime, String[] patterns) {
		return toTimestamp(parseDate(strDateTime, patterns));
	}

	/**
	 * 将 Date 转换为 Timestamp
	 * 
	 * @param date
	 *            需要转换的 Date
	 * @return 转换后的 Timestamp
	 */
	public static Timestamp toTimestamp(Date date) {
		Assert.notNull(date);
		return new Timestamp(date.getTime());
	}

	/**
	 * 将 Timestamp 转换为 Date
	 * 
	 * @param timestamp
	 *            需要转换的 Timestamp
	 * @return 转换后的 Date
	 */
	public static Date toDate(Timestamp timestamp) {
		Assert.notNull(timestamp);
		return new Date(timestamp.getTime());
	}

	/**
	 * 因为 Calendar 的月月份比实际月份小一个，所以我们需要将实际月份减一才可以将实际月份转换成 Calendar 的月份
	 * 
	 * @param realMonth
	 * @return
	 */
	private static int convertRealMonthToCalendarMonth(int realMonth) {
		return realMonth - 1;
	}

	/**
	 * 因为 Calendar 的月月份比实际月份小一个，所以我们需要将 Calendar 月份加一才可以将 Calendar 的月份转换成实际月份
	 * 
	 * @param calendarMonth
	 * @return
	 */
	private static int convertCalendarMonthToRealMonth(int calendarMonth) {
		return calendarMonth + 1;
	}

	public static Date getFirstDayOfMonthForDB(Date today) {
		int year = getYear(today);
		int month = getMonth(today);
		if (getDayOfMonth(today) == 1) {
			month--;
		}
		// 处理跨年的情况
		if (month == 0) {
			year--;
			month = 12;
		}
		return getDate(year, month, 1);
	}

	public static Date getLastDayOfMonthForDB(Date today) {
		int year = getYear(today);
		int month =getMonth(today);
		if (getDayOfMonth(today) != 1) {
			month++;
		}
		// 处理 12 月问题
		if (month == 13) {
			month = 1;
			year++;
		}
		return getDate(year, month, 1);
	}

	public static Date getFirstDayOfQuarterForDB(Date today) {
		// 123 456 789 10 11 12
		int year = getYear(today);
		int month = getMonth(today);
		int day = getDayOfMonth(today);
		if (day == 1) {
			if ((month == 4 || month == 7 || month == 10)) {
				month -= 3;
			} else if (month == 1) {
				month = 10;
				year--;
			}
		}
		if (month >= 1 && month <= 3) {
			month = 1;
		} else if (month >= 4 && month <= 6) {
			month = 4;
		} else if (month >= 7 && month <= 9) {
			month = 7;
		} else if (month >= 10 && month <= 12) {
			month = 10;
		}

		return getDate(year, month, 1);
	}

	public static Date getLastDayOfQuarterForDB(Date today) {
		// 123 456 789 10 11 12
		int year = getYear(today);
		int month = getMonth(today);
		
		if (!(month == 1 || month == 4 || month == 7 || month == 10)) {
			if (month >= 1 && month <= 3) {
				month = 4;
			} else if (month >= 4 && month <= 6) {
				month = 7;
			} else if (month >= 7 && month <= 9) {
				month = 10;
			} else if (month >= 10 && month <= 12) {
				month = 1;
				year++;
			}
		}
		return getDate(year, month, 1);
	}

	/**
	 * 取得时间与当前时间的差距,格式是N小时N分钟前
	 * 
	 * @param date
	 *            Date
	 * @return String
	 */
	public static String getDiffFromNow(Date date) {
		Date nowDate = new Date();
		Long nowLong = nowDate.getTime() / 1000;
		Long dateLong = date.getTime() / 1000;
		String returnValue = "";
		Long diffLong = nowLong - dateLong;
		Long secondLong = diffLong / 60L;
		if (secondLong == 0) {
			returnValue = "不到1分钟前";
		} else if (secondLong < 60) {
			returnValue = secondLong + "分钟前";
		} else {
			Long hourLong = secondLong / 60L;
			secondLong = secondLong - 60L * hourLong;
			returnValue = hourLong + "小时" + secondLong + "分钟前";
		}
		return returnValue;
	}

	/************************ Holin Ding add 2010-03-24 *********************************************/
	/**
	 * 查询当前时间（年月）.
	 * 
	 * @return String
	 */
	public static String getYM() {
		return getYM(0);
	}

	/**
	 * 查询与当前时间相差 i 个月的时间（年月）.
	 * 
	 * @param i
	 * @return String
	 */
	public static String getYM(int i) {
		return getYM(i, getYear(), getMonth());
	}

	/**
	 * 查询与特定时间（年月）str，相差 i 个月的时间（年月）.
	 * 
	 * @param str
	 * @param i
	 * @return String
	 */
	public static String getYM(String str, int i) {
		int year = 0;
		int month = 0;
		try {
			year = Integer.parseInt(str.substring(0, 4));
			month = Integer.parseInt(str.substring(4, 6));
		} catch (Exception e) {
			e.printStackTrace();
		}

		return getYM(i, year, month);
	}

	/**
	 * 取得计算结果，返回String类型：YYYYMM.
	 * 
	 * @param i
	 * @param year
	 * @param month
	 * @return String
	 */
	public static String getYM(int i, int year, int month) {

		/*
		 * Calendar calendar = new GregorianCalendar();
		 * calendar.set(Calendar.YEAR, year); calendar.set(Calendar.MONTH,
		 * month-1);
		 */
		Calendar calendar = new GregorianCalendar(year, month, 0);
		calendar.add(Calendar.MONTH, i);

		year = calendar.get(Calendar.YEAR);
		month = calendar.get(Calendar.MONTH) + 1;

		String ym = null;
		if (month < 10) {
			ym = "" + year + "0" + month;
		} else {
			ym = "" + year + month;
		}
		return ym;
	}

	/**
	 * 查询当前时间（年月日）.
	 * 
	 * @return Timestamp
	 */
	public static Timestamp getYMD() {
		return getYMD(0);
	}

	/**
	 * 查询与当前时间相差 i 天（按月）的时间（年月日）；取得计算结果，返回Timestamp类型.
	 * 
	 * @param i
	 * @return Timestamp
	 */
	public static Timestamp getYMD(int i) {

		Calendar calendar = new GregorianCalendar();
		calendar.add(Calendar.DAY_OF_MONTH, i);

		return new Timestamp((calendar.getTime()).getTime());
	}

	/**
	 * 查询与特定时间相差 i 天（按月）的时间（年月日）：YYYY-MM-DD；取得计算结果，返回String类型：YYYY-MM-DD.
	 * 
	 * @param time
	 * @param i
	 * @return String
	 */
	public static String getYMDByDay(String time, int i) {
		int year = 0;
		int month = 0;
		int day = 0;
		try {
			year = Integer.parseInt(time.substring(0, 4));
			month = Integer.parseInt(time.substring(5, 7)) - 1;
			day = Integer.parseInt(time.substring(8, 10));
		} catch (Exception e) {
			e.printStackTrace();
		}

		Calendar calendar = new GregorianCalendar(year, month, day);
		calendar.add(Calendar.DAY_OF_MONTH, i);

		return (new Timestamp((calendar.getTime()).getTime()).toString())
				.substring(0, 10);
	}

	/**
	 * 查询与特定时间相差 i 月的时间（年月日）：YYYY-MM-DD；取得计算结果，返回String类型：YYYY-MM-DD.
	 * 
	 * @param time
	 * @param i
	 * @return String
	 */
	public static String getYMDByMonth(String time, int i) {
		int year = 0;
		int month = 0;
		int day = 0;
		try {
			year = Integer.parseInt(time.substring(0, 4));
			month = Integer.parseInt(time.substring(5, 7)) - 1;
			day = Integer.parseInt(time.substring(8, 10));
		} catch (Exception e) {
			e.printStackTrace();
		}

		Calendar calendar = new GregorianCalendar(year, month, day);
		calendar.add(Calendar.MONTH, i);

		return (new Timestamp((calendar.getTime()).getTime()).toString())
				.substring(0, 10);
	}

	/**
	 * 查询与当前年份相差i年的年份.
	 * 
	 * @return int
	 */
	public static int getYear(int i) {
		Calendar calendar = new GregorianCalendar();
		calendar.add(Calendar.YEAR, i);
		int year = calendar.get(Calendar.YEAR);
		return year;
	}

	/**
	 * 查询与当前月份相差i月的月份.
	 * 
	 * @return int
	 */
	public static int getMonth(int i) {
		Calendar calendar = new GregorianCalendar();
		calendar.add(Calendar.MONTH, i);
		int month = calendar.get(Calendar.MONTH) + 1;
		return month;
	}

	/**
	 * 查询与当前天数（按月）相差i天的天数.
	 * 
	 * @return int
	 */
	public static int getDay(int i) {
		Calendar calendar = new GregorianCalendar();
		calendar.add(Calendar.DAY_OF_MONTH, i);
		int day = calendar.get(Calendar.DAY_OF_MONTH);
		return day;
	}

	/**
	 * 查询当前年份.
	 * 
	 * @return int
	 */
	public static int getYear() {
		Calendar calendar = new GregorianCalendar();
		int year = calendar.get(Calendar.YEAR);
		return year;
	}

	/**
	 * 查询当前月份.
	 * 
	 * @return int
	 */
	public static int getMonth() {
		Calendar calendar = new GregorianCalendar();
		int month = calendar.get(Calendar.MONTH) + 1;
		return month;
	}

	/**
	 * 查询当前天数（按月）.
	 * 
	 * @return int
	 */
	public static int getDay() {
		Calendar calendar = new GregorianCalendar();
		int day = calendar.get(Calendar.DAY_OF_MONTH);
		return day;
	}
	/**
	 * 
	 * @方法名：getSeqDate
	 * @功能描述：获得yyyyMMdd格式的日期
	 * @创建人：刘志刚
	 * @创建时间：Aug 17, 2011 9:35:07 AM
	 * @参数：@return
	 * @返回：String
	 * @throws
	 */
	public static String getSeqDate(){
		Date date=new Date();
		SimpleDateFormat sf=new SimpleDateFormat("yyyyMMdd");
		return sf.format(date);
	}
		
	public static  Date getDateAfterSeconds(int seconds){
		long now=System.currentTimeMillis()+seconds*1000;
		return new Date(now);
	}

	/**
	 * 
	 * @方法名：getDate
	 * @功能描述：获得yyyyMM格式的日期
	 * @创建人：
	 * @参数：@return
	 * @返回：String
	 * @throws
	 */
	public static String getMouthDate(){
		Date date=new Date();
		SimpleDateFormat sdf=new SimpleDateFormat("yyyyMM");
		return sdf.format(date);

	}
	/**
	 * 
	 * @方法名：getSecond
	 * @功能描述：根据所给日期返回两日期相差的秒数
	 * @创建人：Holin Ding
	 * @创建时间：Oct 27, 2011 1:24:42 PM
	 * @参数：@param startDate
	 * @参数：@param endDate
	 * @参数：@return
	 * @返回：Long 返回两个日期间隔的毫秒数
	 * @throws
	 */
	public static Long getSecond(Date startDate, Date endDate) {
		long a1 = startDate.getTime();   
        long a2 = endDate.getTime();
        return a1 - a2;
	}
	
	/**
	 * @方法名：dateToString
	 * @功能描述：将yyyyMMdd格式的日期转为yyyy年MM月dd日格式字符串
	 * @创建人：Holin Ding
	 * @创建时间：Nov 8, 2011 12:20:42 PM
	 * @参数：@param date
	 * @参数：@return
	 * @返回：String
	 * @throws
	 */
	public static String dateToString (String date)   {
		String result = "";
		if (date == null) {
			result = "";
		} else {
			String y = date.substring(0, 4);
			String m = date.substring(4, 6);
			String d = date.substring(6, 8);
			
			result = y + "年" + m + "月" + d + "日";
		}
		return result;
	} 
	
	/**
	 * 两个日期的年月一样则返回true
	 * @param d1
	 * @param d2
	 * @return
	 */
	public static boolean isSameYM(Date d1,Date d2){
		int y1=getYear(d1),y2=getYear(d2);
		int m1=getMonth(d1),m2=getMonth(d2);
		if(y1==y2&&m1==m2)
			return true;
		else
			return false;
	}
	/**
	 * 返回两个日期之间的月份数组   格式为[yyyy-MM]
	 * @param beginDate
	 * @param endDate
	 * @return
	 */
	public static String[] getBetweenMonthAry(Date beginDate,Date endDate){
		if(beginDate==null||endDate==null||isStartBeforeEndDate(endDate, beginDate))
			return null;
		beginDate=resetTime(beginDate);
		Date tmpDate=beginDate;
		endDate=resetTime(endDate);
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM");
		LinkedList<String> list=new LinkedList<String>();
		if(isSameYM(tmpDate, endDate)){
			list.add(sdf.format(tmpDate));
		}else{
			while(!isSameYM(tmpDate, endDate)){
				list.add(sdf.format(tmpDate));
				tmpDate=addMonths(tmpDate, 1);
			}
			list.add(sdf.format(tmpDate));
		}
		return CommonUtil.listToArray(list);
	}
	
	/**
	 * 返回两个日期之间的月份数组   格式为[yyyy-MM]
	 * @param beginDate
	 * @param endDate
	 * @return
	 * @throws ParseException 
	 */
	public static String[] getBetweenMonthAry(String begin,String end) throws ParseException{
		if(begin==null||begin==null||begin.compareTo(end)>0)
			return null;
		if(begin.equals(end)){
			return new String[]{begin};
		}
		LinkedList<String> list=new LinkedList<String>();
		String tmp=begin;
		while(!tmp.equals(end)){
			list.add(tmp);
			tmp=getNextMonth(tmp);
		}
		list.add(end);
		return CommonUtil.listToArray(list);
	}
	
	/**
	 * 获取上一个月份 格式yyyy-MM
	 * @param month
	 * @return yyyy-MM
	 * @throws ParseException 
	 */
	public static String getPreMonth(String month) throws ParseException{
		
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM");
		Date d=sdf.parse(month);
		d=addMonths(d, -1);
		return sdf.format(d);
	}
	
	/**
	 * 获取上一个月份 格式yyyy-MM
	 * @param month
	 * @return yyyy-MM
	 * @throws ParseException 
	 */
	public static Date getPreMonth(Date month) throws ParseException{
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM");
		
		Date d=sdf.parse(sdf.format(month));
		d=addMonths(d, -1);
		return d;
	}
	
	/**
	 * 获取下一个月份 格式yyyy-MM
	 * @param month
	 * @return yyyy-MM
	 * @throws ParseException 
	 */
	public static String getNextMonth(String month) throws ParseException{
		
		SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM");
		Date d=sdf.parse(month);
		d=addMonths(d, 1);
		return sdf.format(d);
	}
	
	/**
	 * 获得时间
	 * 
	 * @param date
	 * @return
	 */
	public static Date getDate(Date date) {
		return getDate(date, null);
	}

	/**
	 * 取得当前日期的0点0分0秒
	 * 
	 * @return {@link Date}
	 */
	public static Date getDate() {
		return getDate(new Date(), null);
	}

	/**
	 * 取得:(当前日期的0点0分0秒+24小时)之后的同一时刻， 也就是当前日期之后一天的0点0分0秒
	 * 
	 * @return {@link Date}
	 */
	public static Date getNextDate() {
		Date d = getDate();
		return new Date(d.getTime() + 86400000);
	}
	
	/**
	 * 取得:(当前日期的0点0分0秒+24小时)之后的同一时刻， 也就是当前日期之后七天天的0点0分0秒
	 * 
	 * @return {@link Date}
	 */
	public static Date getNextWeek() {
		Date d = getDate();
		return new Date(d.getTime() + 86400000 * 7);
	}
	
	public static Date getNextWeek(Date d) {
		return new Date(d.getTime() + 86400000 * 7);
	}
	
	/**
	 * 获取几天后的日期
	 * 
	 * @param i
	 * @return
	 */
	public static Date getNextDay(int i) {
		Date d = getDate();
		return new Date(d.getTime() + 86400000 * i);
	}
	/**
	 * 取得:(给定日期的0点0分0秒+24小时)之后的同一时刻， 也就是当前日期之后一天的0点0分0秒
	 * 
	 * @return {@link Date}
	 */
	public static Date getNextDate(Date d) {
		return new Date(d.getTime() + 86400000);
	}

	/**
	 * 获得相映时间，可以带格式
	 * 
	 * @return
	 */
	public static Date getDate(Date date, String format) {
		SimpleDateFormat simpleDateFormat = null;

		if (format == null) {
			simpleDateFormat = new SimpleDateFormat(DATE_FORMAT,
					java.util.Locale.CHINA);
		} else {
			simpleDateFormat = new SimpleDateFormat(format,
					java.util.Locale.CHINA);
		}

		String source = simpleDateFormat.format(date);
		try {
			date = simpleDateFormat.parse(source);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

    /**
     * 获取给定日期前一个月的1号
     * @param d
     * @return
     */
    public static Date getPreMonthStart(Date d){
    	if(d == null){
    		d = new Date();
    	}
		GregorianCalendar c = new GregorianCalendar();
		c.set(Calendar.DATE, 1);
		c.set(Calendar.HOUR_OF_DAY, 0);
		c.set(Calendar.MINUTE, 0);
		c.set(Calendar.SECOND, 0);
		c.roll(Calendar.MONTH, false);
		c.add(Calendar.DATE, -1);
    	return c.getTime();
    }
    
    public static Date getBeginDate(Date d){
    	if(d!=null){
    		Calendar c= Calendar.getInstance();
    		c.setTime(d);
    		c.set(Calendar.HOUR_OF_DAY, 0);
    		c.set(Calendar.MINUTE, 0);
    		c.set(Calendar.SECOND, 0);
    		return c.getTime();
    	}
    	return null;
    }
    public static Date getEndDate(Date d){
    	if(d!=null){
    		Calendar c= Calendar.getInstance();
    		c.setTime(d);
    		c.set(Calendar.HOUR_OF_DAY, 23);
    		c.set(Calendar.MINUTE, 59);
    		c.set(Calendar.SECOND, 59);
    		return c.getTime();
    	}
    	return null;
    }
        /**
         * 两个时间之间相差距离多少天
         * @param one 时间参数 1：
         * @param two 时间参数 2：系统当前时间
         * @return 相差天数
         */
        public static long getDistanceDays(String str1, String str2) throws Exception{
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            Date one;
            Date two;
            long days=0;
            try {
                one = df.parse(str1);
                two = df.parse(str2);
                long time1 = one.getTime();
                long time2 = two.getTime();
                long diff ;
                    diff = time2 - time1;
                
                days = diff / (1000 * 60 * 60 * 24);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return days;
        }

    
}